import { format as formatDate, parse } from 'date-fns';
import { zhCN, enUS, Locale } from 'date-fns/locale';
import { getConfig } from '../services/configService';

// 时间字段类型
export type TimeFieldType = 'start' | 'created' | 'updated' | 'general';

// 时间格式配置接口
export interface TimeFormatConfig {
  dateFormat: string;
  timeFormat: string;
  showTime: boolean;
  showSeconds: boolean;
}

// 解析日期格式字符串为date-fns格式
function parseDateFormat(format: string): string {
  switch (format) {
    case 'YYYY-MM-DD':
      return 'yyyy-MM-dd';
    case 'MM/DD/YYYY':
      return 'MM/dd/yyyy';
    case 'DD/MM/YYYY':
      return 'dd/MM/yyyy';
    case 'YYYY年MM月DD日':
      return 'yyyy年MM月dd日';
    case 'DD MMM YYYY':
      return 'dd MMM yyyy';
    case 'MMM DD, YYYY':
      return 'MMM dd, yyyy';
    default:
      return 'yyyy-MM-dd';
  }
}

// 解析时间格式
function parseTimeFormat(format: string, showSeconds: boolean = true): string {
  // 基础格式
  let timeFormat: string;
  
  switch (format) {
    case '24':
      timeFormat = 'HH:mm';
      break;
    case '12':
      timeFormat = 'hh:mm a';
      break;
    default:
      timeFormat = 'HH:mm';
  }
  
  // 如果需要显示秒，添加秒部分
  if (showSeconds) {
    // 找到分钟后面的位置
    const minuteEndPos = timeFormat.indexOf('mm') + 2;
    // 在分钟后面插入秒格式
    timeFormat = timeFormat.substring(0, minuteEndPos) + ':ss' + timeFormat.substring(minuteEndPos);
  }
  
  return timeFormat;
}

// 获取当前语言的locale
function getLocale(language: string): Locale {
  return language === 'zh-CN' ? zhCN : enUS;
}

// 获取特定字段的格式化配置
async function getFieldFormatConfig(fieldType: TimeFieldType): Promise<TimeFormatConfig> {
  try {
    const config = await getConfig();
    
    // 根据字段类型返回对应配置
    switch (fieldType) {
      case 'start':
        return config.general.startTimeFormat;
      case 'created':
        return config.general.createdTimeFormat;
      case 'updated':
        return config.general.updatedTimeFormat;
      case 'general':
      default:
        // 返回默认值而不是使用通用配置
        return {
          dateFormat: 'YYYY-MM-DD',
          timeFormat: '24',
          showTime: true,
          showSeconds: true
        };
    }
  } catch (error) {
    console.error('获取字段格式配置失败，使用默认值', error);
    // 返回默认配置
    return {
      dateFormat: 'YYYY-MM-DD',
      timeFormat: '24',
      showTime: true,
      showSeconds: true
    };
  }
}

// 从localStorage获取字段格式配置（同步版本）
function getFieldFormatConfigSync(fieldType: TimeFieldType): TimeFormatConfig {
  try {
    // 尝试从localStorage获取配置
    const generalSettings = localStorage.getItem('general-settings');
    if (generalSettings) {
      const settings = JSON.parse(generalSettings);
      
      // 根据字段类型返回对应配置
      switch (fieldType) {
        case 'start':
          if (settings.startTimeFormat) return settings.startTimeFormat;
          break;
        case 'created':
          if (settings.createdTimeFormat) return settings.createdTimeFormat;
          break;
        case 'updated':
          if (settings.updatedTimeFormat) return settings.updatedTimeFormat;
          break;
      }
      
      // 如果没有找到特定配置，返回默认配置（不再使用通用配置）
      return {
        dateFormat: 'YYYY-MM-DD',
        timeFormat: '24',
        showTime: true,
        showSeconds: true
      };
    }
    
    // 找不到配置，返回默认值
    return {
      dateFormat: 'YYYY-MM-DD',
      timeFormat: '24',
      showTime: true,
      showSeconds: true
    };
  } catch (error) {
    console.error('获取本地存储的字段格式配置失败，使用默认格式', error);
    return {
      dateFormat: 'YYYY-MM-DD',
      timeFormat: '24',
      showTime: true,
      showSeconds: true
    };
  }
}

/**
 * 格式化特定类型的时间字段
 * @param date 要格式化的日期（字符串、Date对象或时间戳）
 * @param fieldType 时间字段类型（start/created/updated/general）
 * @returns 格式化后的日期字符串
 */
export async function formatTimeField(
  date: string | Date | number,
  fieldType: TimeFieldType = 'general'
): Promise<string> {
  try {
    // 处理日期对象
    let dateObj: Date;
    if (date instanceof Date) {
      dateObj = date;
    } else if (typeof date === 'string') {
      // 尝试解析字符串日期
      dateObj = new Date(date);
    } else if (typeof date === 'number') {
      // 处理时间戳
      dateObj = new Date(date);
    } else {
      return '';
    }

    // 检查日期是否有效
    if (isNaN(dateObj.getTime())) {
      return typeof date === 'string' ? date : '';
    }

    // 获取这个特定字段的配置
    const fieldConfig = await getFieldFormatConfig(fieldType);
    
    // 转换日期格式
    const dateFormatStr = parseDateFormat(fieldConfig.dateFormat);
    const timeFormatStr = parseTimeFormat(fieldConfig.timeFormat, fieldConfig.showSeconds);
    
    // 获取当前语言
    const config = await getConfig();
    const locale = getLocale(config.general.language);

    // 格式化日期时间
    const formatStr = fieldConfig.showTime ? `${dateFormatStr} ${timeFormatStr}` : dateFormatStr;
    return formatDate(dateObj, formatStr, { locale });
  } catch (error) {
    console.error('日期格式化错误:', error);
    return typeof date === 'string' ? date : '';
  }
}

/**
 * 格式化特定类型的时间字段（同步版本）
 * @param date 要格式化的日期（字符串、Date对象或时间戳）
 * @param fieldType 时间字段类型（start/created/updated/general）
 * @returns 格式化后的日期字符串
 */
export function formatTimeFieldSync(
  date: string | Date | number,
  fieldType: TimeFieldType = 'general'
): string {
  try {
    // 处理日期对象
    let dateObj: Date;
    if (date instanceof Date) {
      dateObj = date;
    } else if (typeof date === 'string') {
      // 尝试解析字符串日期
      dateObj = new Date(date);
    } else if (typeof date === 'number') {
      // 处理时间戳
      dateObj = new Date(date);
    } else {
      return '';
    }

    // 检查日期是否有效
    if (isNaN(dateObj.getTime())) {
      return typeof date === 'string' ? date : '';
    }

    // 获取这个特定字段的配置
    const fieldConfig = getFieldFormatConfigSync(fieldType);
    
    // 转换日期格式
    const dateFormatStr = parseDateFormat(fieldConfig.dateFormat);
    const timeFormatStr = parseTimeFormat(fieldConfig.timeFormat, fieldConfig.showSeconds);
    
    // 获取语言设置
    const language = localStorage.getItem('language') || 'zh-CN';
    const locale = getLocale(language);

    // 格式化日期时间
    const formatStr = fieldConfig.showTime ? `${dateFormatStr} ${timeFormatStr}` : dateFormatStr;
    return formatDate(dateObj, formatStr, { locale });
  } catch (error) {
    console.error('日期格式化错误:', error);
    return typeof date === 'string' ? date : '';
  }
}

/**
 * 解析字符串日期为Date对象
 * @param dateStr 日期字符串
 * @param formatStr 日期字符串的格式
 * @returns Date对象
 */
export function parseDateTime(dateStr: string, formatStr?: string): Date | null {
  try {
    // 如果没有指定格式，尝试自动解析
    if (!formatStr) {
      return new Date(dateStr);
    }
    
    return parse(dateStr, formatStr, new Date());
  } catch (error) {
    console.error('解析日期失败:', error);
    return null;
  }
}

// 为兼容以前的API，保留原来的函数，但内部调用新函数
export async function formatDateTime(
  date: string | Date | number,
  showTime: boolean = true,
  useUserConfig: boolean = true
): Promise<string> {
  try {
    // 调用新的API
    const result = await formatTimeField(date, 'general');
    return result;
  } catch (error) {
    console.error('日期格式化错误:', error);
    return typeof date === 'string' ? date : '';
  }
}

export function formatDateTimeSync(
  date: string | Date | number,
  showTime: boolean = true
): string {
  try {
    // 调用新的API
    return formatTimeFieldSync(date, 'general');
  } catch (error) {
    console.error('日期格式化错误:', error);
    return typeof date === 'string' ? date : '';
  }
}

/**
 * 获取当前日期时间的格式化字符串
 */
export async function getCurrentDateTime(fieldType: TimeFieldType = 'general'): Promise<string> {
  return formatTimeField(new Date(), fieldType);
} 